home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / editors / emcs1857 / 1857sr~1.zoo / src / chartab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  17.0 KB  |  666 lines
  1. /* GNU Emacs routines to deal with char tables.
  2.    Copyright (C) 1987, 1990 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU Emacs.
  5.  
  6. GNU Emacs is distributed in the hope that it will be useful,
  7. but WITHOUT ANY WARRANTY.  No author or distributor
  8. accepts responsibility to anyone for the consequences of using it
  9. or for whether it serves any particular purpose or works at all,
  10. unless he says so in writing.  Refer to the GNU Emacs General Public
  11. License for full details.
  12.  
  13. Everyone is granted permission to copy, modify and redistribute
  14. GNU Emacs, but only under the conditions described in the
  15. GNU Emacs General Public License.   A copy of this license is
  16. supposed to have been given to you along with GNU Emacs so you
  17. can know your rights and responsibilities.  It should be in a
  18. file named COPYING.  Among other things, the copyright notice
  19. and this notice must be preserved on all copies.  */
  20.  
  21. /* Written by:
  22. Howard Gayle
  23. TN/ETX/TT/HL
  24. Ericsson Telecom AB
  25. S-126 25 Stockholm
  26. Sweden
  27. howard@ericsson.se
  28. uunet!ericsson.se!howard
  29. Phone: +46 8 719 5565
  30. FAX  : +46 8 719 8439
  31. */
  32.  
  33. #include "config.h"
  34. #include "lisp.h"
  35. #include "chartab.h"
  36. #include "etctab.h"
  37. #include "buffer.h"
  38.  
  39. Lisp_Object Qchar_table_p;
  40. Lisp_Object Vbackslash_char_table;
  41. Lisp_Object Vctl_arrow_char_table;
  42.  
  43. extern Lisp_Object build_string ();
  44. extern Lisp_Object intern ();
  45.  
  46. #define MAXGLYFSTR 22 /* Max chars in a glyf. */
  47. #define GLYF_DELTA 1024 /* Grow glyf table by this many bytes each time. */
  48.  
  49. char_t *glyf_table;
  50. char_t *glyf_next; /* Next free position in glyf_table. */
  51. int glyf_table_size; /* Size of glyf table in bytes. */
  52. int glyf_space_left; /* Current free bytes in glyf table. */
  53. glyf_t max_glyf; /* Maximum legal glyf_t. */
  54.  
  55. extern Lisp_Object Vxterm;
  56.  
  57. DEFUN ("new-glyf", Fnew_glyf, Snew_glyf, 1, 1, 0,
  58.        "Return a newly created glyf for the given string.")
  59.   (s)
  60.      Lisp_Object s; /* String. */
  61. {
  62.   register int     l; /* String length. */
  63.   register char_t *p; /* Misc. pointer. */
  64.   register Lisp_Object z;
  65.  
  66.   CHECK_STRING (s, 0);
  67.   l = XSTRING (s)->size;
  68.  
  69. #ifdef HAVE_X_WINDOWS
  70.   if (!NULL (Vxterm))
  71.     {
  72.       if (1 != l) arg_out_of_range (s);
  73.       XFASTINT (z) = (1 << 8) | XSTRING(s)->data[0];
  74.       return (z);
  75.     }
  76. #endif
  77.  
  78.   if ((l < 1) || (l > MAXGLYFSTR)) arg_out_of_range (s);
  79.   while (l > glyf_space_left)
  80.     {
  81.       p = (char_t *) xrealloc ((long *) glyf_table, glyf_table_size + GLYF_DELTA);
  82.       glyf_table = p;
  83.       glyf_table_size += GLYF_DELTA;
  84.       glyf_space_left += GLYF_DELTA;
  85.       glyf_next = p + max_glyf + glyf_len (max_glyf) + 1;
  86.     }
  87.   p = glyf_next;
  88.   if ((p - glyf_table) <= max_glyf) abort ();
  89.   max_glyf = p - glyf_table;
  90.   *p++ = l;
  91.   bcopy (XSTRING(s)->data, p, l);
  92.   glyf_next = p + l;
  93.   glyf_space_left -= l + 1;
  94.   XFASTINT (z) = max_glyf;
  95.   return (z);
  96. }
  97.  
  98. DEFUN ("find-glyf", Ffind_glyf, Sfind_glyf, 1, 1, 0,
  99.        "Return the glyf for the given string, or nil if there is none.")
  100.   (s)
  101.      Lisp_Object s; /* String. */
  102. {
  103.   register int     l;  /* String length. */
  104.   register char_t *p;  /* Steps through glyf table. */
  105.   register char_t *q;  /* End of glyf table. */
  106.   register char_t *sd; /* String data. */
  107.   register Lisp_Object z;
  108.  
  109.   CHECK_STRING (s, 0);
  110.   l = XSTRING (s)->size;
  111.   sd = XSTRING (s)->data;
  112.  
  113. #ifdef HAVE_X_WINDOWS
  114.   if (!NULL (Vxterm))
  115.     {
  116.       if (1 != l) arg_out_of_range (s);
  117.       XFASTINT (z) = (1 << 8) | *sd;
  118.       return (z);
  119.     }
  120. #endif
  121.  
  122.   if ((l < 1) || (l > MAXGLYFSTR)) arg_out_of_range (s);
  123.   p = glyf_table + SPACEGLYF;
  124.   q = glyf_next;
  125.   while ((p < q) && ((l != *p) || strncmp (p + 1, sd, l)))
  126.     p += *p + 1;
  127.   if (p >= q)
  128.     return (Qnil);
  129.   else
  130.     {
  131.       XFASTINT (z) = p - glyf_table;
  132.       return (z);
  133.     }
  134. }
  135.  
  136. DEFUN ("get-glyf", Fget_glyf, Sget_glyf, 1, 1, 0,
  137.        "Return the glyf for the given string, or make one if there is none.")
  138.   (s)
  139.      Lisp_Object s; /* String. */
  140. {
  141.   register Lisp_Object g = Ffind_glyf (s);
  142.  
  143.   return (NULL (g) ? Fnew_glyf (s) : g);
  144. }
  145.  
  146. DEFUN ("glyf-stats", Fglyf_stats, Sglyf_stats, 0, 0, 0,
  147.        "Return (max_glyf glyf_table_size glyf_space_left).")
  148.   ()
  149. {
  150.   return (Fcons (XFASTINT (max_glyf),
  151.          Fcons (XFASTINT (glyf_table_size),
  152.             Fcons (XFASTINT (glyf_space_left), Qnil))));
  153. }
  154.  
  155. int
  156. glyf_len (g)
  157.      register glyf_t g;
  158. {
  159.   register int l;
  160.  
  161.   if (g < SPACEGLYF) abort ();
  162.   if (g > max_glyf) abort ();
  163.  
  164. #ifdef HAVE_X_WINDOWS
  165.   if (!NULL (Vxterm)) return (1);
  166. #endif
  167.  
  168.   l = glyf_table[g];
  169.   if (l > MAXGLYFSTR) abort ();
  170.   return (l);
  171. }
  172.  
  173. char_t *
  174. glyf_str (g)
  175.      register glyf_t g;
  176. {
  177.   static char_t b[2]; /* For X windows glyf.*/
  178.  
  179.   if (g < SPACEGLYF) abort ();
  180.   if (g > max_glyf) abort ();
  181.  
  182. #ifdef HAVE_X_WINDOWS
  183.   if (!NULL (Vxterm))
  184.     {
  185.       b[0] = 0377 & g;
  186.       return (b);
  187.     }
  188. #endif
  189.  
  190.   return (glyf_table + g + 1);
  191. }
  192.  
  193. /* Return the glyf_t encoded by a Lisp integer.  Check for errors. */
  194. static glyf_t
  195. get_glyf_arg (obj)
  196.      register Lisp_Object obj;
  197. {
  198.   register int i;
  199.  
  200.   CHECK_NUMBER (obj, 1);
  201.   i = XINT (obj);
  202.   if ((i < SPACEGLYF) || (i > max_glyf)) arg_out_of_range (obj);
  203.   return ((glyf_t) i);
  204. }
  205.  
  206. DEFUN ("glyf-to-string", Fglyf_to_string, Sglyf_to_string, 1, 1, 0,
  207.        "Return the bytes of glyf G.")
  208.   (obj)
  209.      Lisp_Object obj;
  210. {
  211.   register glyf_t g = get_glyf_arg (obj);
  212.  
  213.   return (make_string (glyf_str (g), glyf_len (g)));
  214. }
  215.  
  216. DEFUN ("char-table-p", Fchar_table_p, Schar_table_p, 1, 1, 0,
  217.        "Return t iff ARG is a char_table.")
  218.   (obj)
  219.      Lisp_Object obj;
  220. {
  221.   return ((XTYPE (obj) == Lisp_Chartab) ? Qt : Qnil);
  222. }
  223.  
  224. Lisp_Object
  225. check_char_table (obj)
  226.      Lisp_Object obj;
  227. {
  228.   register Lisp_Object tem;
  229.  
  230.   while (tem = Fchar_table_p (obj), NULL (tem))
  231.     obj = wrong_type_argument (Qchar_table_p, obj, 0);
  232.   return (obj);
  233. }   
  234.  
  235. DEFUN ("backslash-char-table",
  236.        Fbackslash_char_table, Sbackslash_char_table, 0, 0, 0,
  237.        "Return the backslash char table.")
  238.   ()
  239. {
  240.   return (Vbackslash_char_table);
  241. }
  242.  
  243. DEFUN ("ctl-arrow-char-table",
  244.        Fctl_arrow_char_table, Sctl_arrow_char_table, 0, 0, 0,
  245.        "Return the ctl-arrow char table.")
  246.   ()
  247. {
  248.   return (Vctl_arrow_char_table);
  249. }
  250.  
  251.  
  252. DEFUN ("copy-char-table", Fcopy_char_table, Scopy_char_table, 0, 1, 0,
  253.        "Construct a new char table and return it.\n\
  254. It is a copy of the TABLE, which defaults to default-buffer-char-table.")
  255.   (table)
  256.      Lisp_Object table;
  257. {
  258.   register struct Lisp_Chartab *ot; /* Old char table. */
  259.   register struct Lisp_Chartab *nt; /* New char table. */
  260.   register Lisp_Object           z;  /* Return. */
  261.   
  262.   if (NULL (table)) table = buffer_defaults.buffer_char_table;
  263.   table = check_char_table (table);
  264.   ot = XCHARTAB (table);
  265.   z = make_etc_table (sizeof (struct Lisp_Chartab), Lisp_Chartab);
  266.   nt = XCHARTAB (z);
  267.   bcopy (((char *) &ot->ct_frameg), ((char *) &nt->ct_frameg),
  268.      sizeof (struct Lisp_Chartab) - sizeof (struct Lisp_Etctab));
  269.   return (z);
  270. }
  271.  
  272. DEFUN ("get-char-table-invisc",
  273.        Fget_char_table_invisc, Sget_char_table_invisc, 1, 1, 0,
  274.        "Return the selective display character of the given char table.")
  275.   (char_table)
  276.      register Lisp_Object char_table;
  277. {
  278.   register Lisp_Object invisc;
  279.   
  280.   char_table = check_char_table (char_table);
  281.   XFASTINT (invisc) = XCHARTAB (char_table)->ct_invisc;
  282.   return (invisc);
  283. }
  284.  
  285. DEFUN ("get-char-table-frameg",
  286.        Fget_char_table_frameg, Sget_char_table_frameg, 1, 1, 0,
  287.        "Return the frame glyf of the given char table.")
  288.   (char_table)
  289.      register Lisp_Object char_table;
  290. {
  291.   register Lisp_Object frameg;
  292.   
  293.   char_table = check_char_table (char_table);
  294.   XFASTINT (frameg) = XCHARTAB (char_table)->ct_frameg;
  295.   return (frameg);
  296. }
  297.  
  298. DEFUN ("get-char-table-truncg",
  299.        Fget_char_table_truncg, Sget_char_table_truncg, 1, 1, 0,
  300.        "Return the truncation glyf of the given char table.")
  301.   (char_table)
  302.      register Lisp_Object char_table;
  303. {
  304.   register Lisp_Object truncg;
  305.   
  306.   char_table = check_char_table (char_table);
  307.   XFASTINT (truncg) = XCHARTAB (char_table)->ct_truncg;
  308.   return (truncg);
  309. }
  310.  
  311. DEFUN ("get-char-table-wrapg",
  312.        Fget_char_table_wrapg, Sget_char_table_wrapg, 1, 1, 0,
  313.        "Return the wrap glyf of the given char table.")
  314.   (char_table)
  315.      register Lisp_Object char_table;
  316. {
  317.   register Lisp_Object wrapg;
  318.   
  319.   char_table = check_char_table (char_table);
  320.   XFASTINT (wrapg) = XCHARTAB (char_table)->ct_wrapg;
  321.   return (wrapg);
  322. }
  323.  
  324. DEFUN ("get-char-table-invisr",
  325.        Fget_char_table_invisr, Sget_char_table_invisr, 1, 1, 0,
  326.        "Return the selective display rope of the given char_table.")
  327.   (char_table)
  328.      register Lisp_Object char_table;
  329. {
  330.   register Lisp_Object invisr;
  331.   register Lisp_Object len;
  332.   register struct Lisp_Vector *p;
  333.   register int index;
  334.   
  335.   char_table = check_char_table (char_table);
  336.   XFASTINT (len) = XCHARTAB (char_table)->ct_invisr.r_len;
  337.   invisr = Fmake_vector (len, Qnil);
  338.   p = XVECTOR (invisr);
  339.   for (index = 0; index < XINT (len); index++)
  340.     p->contents[index] =
  341.       XFASTINT (XCHARTAB (char_table)->ct_invisr.r_glyfs[index]);
  342.   return (invisr);
  343. }
  344.  
  345. DEFUN ("get-char-table-dispr",
  346.        Fget_char_table_dispr, Sget_char_table_dispr, 2, 2, 0,
  347.        "Return the terminal display rope in the given char table\n\
  348. for the given character.")
  349.   (char_table, chr)
  350.      register Lisp_Object char_table;
  351.      register Lisp_Object chr;
  352. {
  353.   register Lisp_Object dispr;
  354.   register Lisp_Object len;
  355.   register struct Lisp_Vector *p;
  356.   register int index;
  357.   register struct Lisp_Chartab *cp;
  358.   register glyf_t *q; /* Steps through the rope. */
  359.   register char_t c; /* The character. */
  360.   
  361.   char_table = check_char_table (char_table);
  362.   c = get_char_arg (chr);
  363.   cp = XCHARTAB (char_table);
  364.   XFASTINT (len) = ROPE_LEN (c, cp);
  365.   dispr = Fmake_vector (len, Qnil);
  366.   p = XVECTOR (dispr);
  367.   q = cp->ct_dispr[c].r_glyfs;
  368.   for (index = 0; index < XFASTINT (len); index++)
  369.     p->contents[index] = XFASTINT (*q++);
  370.   return (dispr);
  371. }
  372.  
  373. DEFUN ("put-char-table-invisc",
  374.        Fput_char_table_invisc, Sput_char_table_invisc, 2, 2, 0,
  375.        "Set the selective display character in char table TABLE to C.")
  376.   (char_table, invisc)
  377.      register Lisp_Object char_table;
  378.      register Lisp_Object invisc;
  379. {
  380.   char_table = check_char_table (char_table);
  381.   XCHARTAB (char_table)->ct_invisc = get_char_arg (invisc);
  382.   return (invisc);
  383. }
  384.  
  385. DEFUN ("put-char-table-frameg",
  386.        Fput_char_table_frameg, Sput_char_table_frameg, 2, 2, 0,
  387.        "Set the frame glyf in char table TABLE to G.")
  388.   (char_table, frameg)
  389.      register Lisp_Object char_table;
  390.      register Lisp_Object frameg;
  391. {
  392.   char_table = check_char_table (char_table);
  393.   XCHARTAB (char_table)->ct_frameg = get_glyf_arg (frameg);
  394.   return (frameg);
  395. }
  396.  
  397. DEFUN ("put-char-table-truncg",
  398.        Fput_char_table_truncg, Sput_char_table_truncg, 2, 2, 0,
  399.        "Set the truncation glyf in char table TABLE to G.")
  400.   (char_table, truncg)
  401.      register Lisp_Object char_table;
  402.      register Lisp_Object truncg;
  403. {
  404.   char_table = check_char_table (char_table);
  405.   XCHARTAB (char_table)->ct_truncg = get_glyf_arg (truncg);
  406.   return (truncg);
  407. }
  408.  
  409. DEFUN ("put-char-table-wrapg",
  410.        Fput_char_table_wrapg, Sput_char_table_wrapg, 2, 2, 0,
  411.        "Set the line wrap glyf in char table TABLE to G.")
  412.   (char_table, wrapg)
  413.      register Lisp_Object char_table;
  414.      register Lisp_Object wrapg;
  415. {
  416.   char_table = check_char_table (char_table);
  417.   XCHARTAB (char_table)->ct_wrapg = get_glyf_arg (wrapg);
  418.   return (wrapg);
  419. }
  420.  
  421. DEFUN ("put-char-table-invisr",
  422.        Fput_char_table_invisr, Sput_char_table_invisr, 2, 2, 0,
  423.        "Set the selective display rope in char table TABLE to ROPE.")
  424.   (char_table, invisr)
  425.      register Lisp_Object char_table;
  426.      register Lisp_Object invisr;
  427. {
  428.   register int i;
  429.   register int n;
  430.   register struct Lisp_Vector *p;
  431.   
  432.   char_table = check_char_table (char_table);
  433.   CHECK_VECTOR (invisr, 1);
  434.   p = XVECTOR (invisr);
  435.   n = p->size;
  436.   if (n > MAXROPE) arg_out_of_range (invisr);
  437.   for (i = 0; i != n; ++i)
  438.     get_glyf_arg (p->contents[i]);
  439.   XCHARTAB (char_table)->ct_invisr.r_len = n;
  440.   for (i = 0; i != n; ++i)
  441.     XCHARTAB (char_table)->ct_invisr.r_glyfs[i] = get_glyf_arg (p->contents[i]);
  442.   return (invisr);
  443. }
  444.  
  445. DEFUN ("put-char-table-dispr",
  446.        Fput_char_table_dispr, Sput_char_table_dispr, 3, 3, 0,
  447.        "Set the terminal display rope in char table TABLE for\n\
  448. character C to ROPE.")
  449.   (char_table, chr, disp)
  450.      register Lisp_Object char_table;
  451.      register Lisp_Object chr;
  452.      register Lisp_Object disp;
  453. {
  454.   register int i;
  455.   register int n;
  456.   register struct Lisp_Vector *p;
  457.   register rope_t *rp;
  458.   
  459.   char_table = check_char_table (char_table);
  460.   CHECK_VECTOR (disp, 2);
  461.   p = XVECTOR (disp);
  462.   n = p->size;
  463.   if (n > MAXROPE) arg_out_of_range (disp);
  464.   for (i = 0; i != n; ++i)
  465.     get_glyf_arg (p->contents[i]);
  466.   rp = &(XCHARTAB (char_table)->ct_dispr[get_char_arg (chr)]);
  467.   rp->r_len = n;
  468.   for (i = 0; i != n; ++i)
  469.     rp->r_glyfs[i] = get_glyf_arg (p->contents[i]);
  470.   return (disp);
  471. }
  472.  
  473. static void
  474. init_char_table_common (e, r)
  475.      register glyf_t (*e)(); /* Function to turn one character into a glyf.*/
  476.      int               r;    /* Flag set for reinitialization.*/
  477. {
  478.   register struct Lisp_Chartab *cp;
  479.   register rope_t *rp;
  480.   register int i;
  481.   
  482.   /* Initialization of backslash char table: */
  483.   if (!r)
  484.     Vbackslash_char_table =
  485.       make_etc_table (sizeof (struct Lisp_Chartab), Lisp_Chartab);
  486.   cp = XCHARTAB (Vbackslash_char_table);
  487.   cp->ct_frameg = (*e) ('|');
  488.   cp->ct_truncg = (*e) ('$');
  489.   cp->ct_wrapg  = (*e) ('\\');
  490.   cp->ct_invisc = '\r';
  491.   rp = &cp->ct_invisr;
  492.   rp->r_len = 4;
  493.   rp->r_glyfs[0] = SPACEGLYF;
  494.   rp->r_glyfs[1] = (*e) ('.');
  495.   rp->r_glyfs[2] = (*e) ('.');
  496.   rp->r_glyfs[3] = (*e) ('.');
  497.   rp = cp->ct_dispr;
  498.   for (i = 0; i != 256; ++i)
  499.     {
  500.       rp->r_len = 4;
  501.       rp->r_glyfs[0] = (*e) ('\\');
  502.       rp->r_glyfs[1] = (*e) (((i >> 6) & 07) + '0');
  503.       rp->r_glyfs[2] = (*e) (((i >> 3) & 07) + '0');
  504.       rp->r_glyfs[3] = (*e) (((i >> 0) & 07) + '0');
  505.       ++rp;
  506.     }
  507.   rp = &cp->ct_dispr[' '];
  508.   rp->r_len = 1;
  509.   rp->r_glyfs[0] = SPACEGLYF;
  510.   ++rp;
  511.   for (i = '!'; i <= '~'; ++i)
  512.     {
  513.       rp->r_len = 1;
  514.       rp->r_glyfs[0] = (*e) (i);
  515.       ++rp;
  516.     }
  517.   
  518.   /* Initialization of ctl-arrow char table: */
  519.   if (!r)
  520.     Vctl_arrow_char_table =
  521.       make_etc_table (sizeof (struct Lisp_Chartab), Lisp_Chartab);
  522.   cp = XCHARTAB (Vctl_arrow_char_table);
  523.   cp->ct_frameg = (*e) ('|');
  524.   cp->ct_truncg = (*e) ('$');
  525.   cp->ct_wrapg  = (*e) ('\\');
  526.   cp->ct_invisc = '\r';
  527.   rp = &cp->ct_invisr;
  528.   rp->r_len = 4;
  529.   rp->r_glyfs[0] = SPACEGLYF;
  530.   rp->r_glyfs[1] = (*e) ('.');
  531.   rp->r_glyfs[2] = (*e) ('.');
  532.   rp->r_glyfs[3] = (*e) ('.');
  533.   rp = cp->ct_dispr;
  534.   for (i = 0; i != ' '; ++i)
  535.     {
  536.       rp->r_len = 2;
  537.       rp->r_glyfs[0] = (*e) ('^');
  538.       rp->r_glyfs[1] = (*e) (i ^ 0100);
  539.       ++rp;
  540.     }
  541.   rp = &cp->ct_dispr[' '];
  542.   rp->r_len = 1;
  543.   rp->r_glyfs[0] = SPACEGLYF;
  544.   ++rp;
  545.   for (i = '!'; i <= '~'; ++i)
  546.     {
  547.       rp->r_len = 1;
  548.       rp->r_glyfs[0] = (*e) (i);
  549.       ++rp;
  550.     }
  551.   rp = &cp->ct_dispr[0177];
  552.   rp->r_len = 2;
  553.   rp->r_glyfs[0] = (*e) ('^');
  554.   rp->r_glyfs[1] = (*e) ('?');
  555.   ++rp;
  556.   for (i = 128; i != 256; ++i)
  557.     {
  558.       rp->r_len = 4;
  559.       rp->r_glyfs[0] = (*e) ('\\');
  560.       rp->r_glyfs[1] = (*e) (((i >> 6) & 07) + '0');
  561.       rp->r_glyfs[2] = (*e) (((i >> 3) & 07) + '0');
  562.       rp->r_glyfs[3] = (*e) (((i >> 0) & 07) + '0');
  563.       ++rp;
  564.     }
  565. }
  566.  
  567. /* Glyf corresponding to char c: */
  568. static glyf_t
  569. englyf (c)
  570.      char_t c;
  571. {
  572.   return ((c - ' ') * 2 + SPACEGLYF);
  573. }
  574.  
  575. init_char_table_once ()
  576. {
  577.   register char_t *p;
  578.   register int i;
  579.   
  580.   init_char_table_common (englyf, 0);
  581.   
  582.   /* Initialization of glyf table: */
  583.   glyf_table = (char_t *) malloc (GLYF_DELTA - 16);
  584.   if (!glyf_table) memory_full();
  585.   p = glyf_table;
  586.   
  587.   for (i = 0; i != SPACEGLYF; i += 2)
  588.     {
  589.       *p++ = 1;
  590.       *p++ = '?';
  591.     }
  592.   
  593.   for (i = ' '; i != 0177; ++i)
  594.     {
  595.       *p++ = 1;
  596.       *p++ = i;
  597.     }
  598.   glyf_next = p;
  599.   glyf_table_size = GLYF_DELTA - 16;
  600.   glyf_space_left = GLYF_DELTA - 16 - (p - glyf_table);
  601.   max_glyf = (p - glyf_table) - 2;
  602. }
  603.  
  604. #ifdef HAVE_X_WINDOWS
  605. static glyf_t
  606. englyfx (c)
  607.      char_t c;
  608. {
  609.   return ((1 << 8) + c);
  610. }
  611.  
  612. init_char_table_x ()
  613. {
  614.   init_char_table_common (englyfx, 1);
  615.   max_glyf = 0xffff;
  616. }
  617. #endif
  618.  
  619. /* The following routine is to be used in xdisp.  For copying the 
  620.  ** overlay arrow string into a glyf table.
  621.  ** This is a HACK to fix a bug, nothing else.
  622.  */
  623.  
  624. glyf_t
  625. char_to_glyf (c)
  626.      char c;
  627. {
  628. #ifdef HAVE_X_WINDOWS
  629.   if (!NULL (Vxterm))
  630.     {
  631.       return (englyfx (c));
  632.     }
  633. #endif
  634.   return (englyf (c));
  635. }
  636.  
  637. syms_of_char_table ()
  638. {
  639.   Qchar_table_p = intern ("char-table-p");
  640.   staticpro (&Qchar_table_p);
  641.   staticpro (&Vbackslash_char_table);
  642.   staticpro (&Vctl_arrow_char_table);
  643.   
  644.   defsubr (&Snew_glyf);
  645.   defsubr (&Sfind_glyf);
  646.   defsubr (&Sget_glyf);
  647.   defsubr (&Sglyf_to_string);
  648.   defsubr (&Sglyf_stats);
  649.   defsubr (&Schar_table_p);
  650.   defsubr (&Sbackslash_char_table);
  651.   defsubr (&Sctl_arrow_char_table);
  652.   defsubr (&Scopy_char_table);
  653.   defsubr (&Sget_char_table_invisc);
  654.   defsubr (&Sget_char_table_frameg);
  655.   defsubr (&Sget_char_table_truncg);
  656.   defsubr (&Sget_char_table_wrapg);
  657.   defsubr (&Sget_char_table_invisr);
  658.   defsubr (&Sget_char_table_dispr);
  659.   defsubr (&Sput_char_table_invisc);
  660.   defsubr (&Sput_char_table_frameg);
  661.   defsubr (&Sput_char_table_truncg);
  662.   defsubr (&Sput_char_table_wrapg);
  663.   defsubr (&Sput_char_table_invisr);
  664.   defsubr (&Sput_char_table_dispr);
  665. }
  666.